import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class PowerUsingRecursionRegressionTest0 {

    public static boolean debug = false;

    @Test
    public void test0001() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0001");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.0517771166437575E103d + "'", double2 == 2.0517771166437575E103d);
    }

    @Test
    public void test0002() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0002");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0003() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0003");
        java.lang.Object obj0 = new java.lang.Object();
        java.lang.Class<?> wildcardClass1 = obj0.getClass();
        org.junit.Assert.assertNotNull(wildcardClass1);
    }

    @Test
    public void test0004() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0004");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0005() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0005");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0006() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0006");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0007() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0007");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0008() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0008");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0009() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0009");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test0010() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0010");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0011() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0011");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0012() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0012");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0013() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0013");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0014() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0014");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0015() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0015");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0016() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0016");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test0017() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0017");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 8.167835760036914E54d + "'", double2 == 8.167835760036914E54d);
    }

    @Test
    public void test0018() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0018");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0019() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0019");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0020() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0020");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0021() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0021");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0022() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0022");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0023() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0023");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0024() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0024");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0025() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0025");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0026() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0026");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0027() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0027");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0028() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0028");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0029() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0029");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0030() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0030");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0031() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0031");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0032() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0032");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0033() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0033");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0034() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0034");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0035() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0035");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0036() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0036");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0037() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0037");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0038() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0038");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0039() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0039");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0040() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0040");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0041() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0041");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0042() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0042");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0043() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0043");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0044() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0044");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0045() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0045");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0046() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0046");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0047() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0047");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0048() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0048");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0049() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0049");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0050() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0050");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0051() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0051");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0052() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0052");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0053() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0053");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0054() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0054");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0055() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0055");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0056() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0056");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0057() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0057");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0058() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0058");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0059() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0059");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0060() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0060");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0061() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0061");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0062() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0062");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0063() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0063");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0064() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0064");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test0065() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0065");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0066() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0066");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0067() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0067");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0068() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0068");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0069() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0069");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0070() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0070");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0071() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0071");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0072() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0072");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0073() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0073");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0074() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0074");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5714460626335824E49d + "'", double2 == 2.5714460626335824E49d);
    }

    @Test
    public void test0075() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0075");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0076() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0076");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.0517771166437575E103d + "'", double2 == 2.0517771166437575E103d);
    }

    @Test
    public void test0077() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0077");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0078() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0078");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0079() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0079");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0080() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0080");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0081() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0081");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0082() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0082");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0083() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0083");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0084() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0084");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0085() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0085");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0086() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0086");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0087() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0087");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0088() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0088");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0089() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0089");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0090() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0090");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0091() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0091");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0092() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0092");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0093() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0093");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0094() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0094");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0095() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0095");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0096() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0096");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0097() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0097");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0098() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0098");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0099() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0099");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0100() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0100");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0101() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0101");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0102() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0102");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0103() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0103");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0104() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0104");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0105() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0105");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test0106() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0106");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0107() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0107");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0108() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0108");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0109() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0109");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0110() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0110");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0111() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0111");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0112() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0112");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0113() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0113");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0114() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0114");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0115() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0115");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0116() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0116");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0117() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0117");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0118() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0118");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0119() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0119");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0120() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0120");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0121() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0121");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test0122() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0122");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0123() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0123");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0124() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0124");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0125() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0125");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0126() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0126");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0127() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0127");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0128() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0128");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0129() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0129");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0130() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0130");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0131() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0131");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0132() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0132");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0133() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0133");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0134() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0134");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0135() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0135");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0136() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0136");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0137() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0137");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0138() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0138");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0139() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0139");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0140() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0140");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0141() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0141");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0142() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0142");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0143() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0143");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0144() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0144");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0145() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0145");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0146() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0146");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0147() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0147");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0148() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0148");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0149() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0149");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0150() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0150");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.210245939718362E192d + "'", double2 == 5.210245939718362E192d);
    }

    @Test
    public void test0151() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0151");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0152() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0152");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0153() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0153");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0154() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0154");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0155() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0155");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0156() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0156");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0157() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0157");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0158() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0158");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0159() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0159");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0160() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0160");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0161() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0161");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0162() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0162");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0163() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0163");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0164() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0164");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0165() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0165");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0166() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0166");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0167() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0167");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0168() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0168");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0169() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0169");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0170() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0170");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0171() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0171");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0172() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0172");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0173() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0173");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0174() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0174");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0175() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0175");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0176() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0176");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0177() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0177");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0178() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0178");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0179() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0179");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0180() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0180");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0181() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0181");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0182() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0182");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0183() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0183");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.989595361011175E145d + "'", double2 == 9.989595361011175E145d);
    }

    @Test
    public void test0184() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0184");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0185() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0185");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0186() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0186");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0187() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0187");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0188() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0188");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0189() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0189");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0190() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0190");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0191() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0191");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0192() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0192");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0193() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0193");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0194() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0194");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0195() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0195");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7890485652059027E52d + "'", double2 == 4.7890485652059027E52d);
    }

    @Test
    public void test0196() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0196");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0197() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0197");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0198() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0198");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0199() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0199");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0200() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0200");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0201() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0201");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.0517771166437575E103d + "'", double2 == 2.0517771166437575E103d);
    }

    @Test
    public void test0202() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0202");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0203() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0203");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0204() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0204");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0205() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0205");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0206() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0206");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0207() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0207");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0208() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0208");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0209() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0209");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0210() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0210");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0211() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0211");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0212() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0212");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0213() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0213");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0214() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0214");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0215() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0215");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0216() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0216");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0217() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0217");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0218() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0218");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0219() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0219");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0220() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0220");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0221() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0221");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0222() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0222");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0223() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0223");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0224() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0224");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0225() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0225");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0226() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0226");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0227() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0227");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0228() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0228");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.4435841430422168E69d + "'", double2 == 3.4435841430422168E69d);
    }

    @Test
    public void test0229() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0229");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0230() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0230");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0231() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0231");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0232() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0232");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0233() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0233");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0234() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0234");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0235() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0235");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0236() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0236");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0237() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0237");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0238() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0238");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0239() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0239");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0240() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0240");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0241() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0241");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0242() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0242");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0243() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0243");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0244() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0244");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0245() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0245");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0246() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0246");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0247() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0247");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0248() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0248");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0249() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0249");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0250() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0250");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0251() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0251");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0252() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0252");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0253() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0253");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0254() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0254");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0255() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0255");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0256() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0256");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0257() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0257");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0258() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0258");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0259() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0259");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0260() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0260");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0261() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0261");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0262() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0262");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0263() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0263");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0264() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0264");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0265() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0265");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.989595361011175E145d + "'", double2 == 9.989595361011175E145d);
    }

    @Test
    public void test0266() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0266");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0267() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0267");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0268() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0268");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0269() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0269");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0270() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0270");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0271() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0271");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0272() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0272");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0273() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0273");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0274() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0274");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0275() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0275");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0276() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0276");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0277() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0277");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0278() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0278");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0279() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0279");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0280() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0280");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0281() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0281");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0282() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0282");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0283() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0283");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0284() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0284");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0285() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0285");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0286() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0286");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0287() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0287");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0288() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0288");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0289() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0289");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0290() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0290");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0291() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0291");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0292() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0292");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0293() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0293");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0294() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0294");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0295() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0295");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0296() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0296");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0297() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0297");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0298() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0298");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0299() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0299");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0300() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0300");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0301() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0301");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0302() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0302");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0303() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0303");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0304() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0304");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0305() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0305");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.4435841430422168E69d + "'", double2 == 3.4435841430422168E69d);
    }

    @Test
    public void test0306() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0306");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0307() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0307");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0308() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0308");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7890485652059027E52d + "'", double2 == 4.7890485652059027E52d);
    }

    @Test
    public void test0309() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0309");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0310() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0310");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0311() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0311");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test0312() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0312");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0313() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0313");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0314() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0314");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0315() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0315");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0316() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0316");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0317() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0317");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0318() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0318");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0319() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0319");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0320() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0320");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0321() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0321");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0322() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0322");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0323() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0323");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0324() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0324");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0325() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0325");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test0326() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0326");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0327() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0327");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0328() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0328");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0329() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0329");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0330() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0330");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0331() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0331");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0332() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0332");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0333() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0333");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.4435841430422168E69d + "'", double2 == 3.4435841430422168E69d);
    }

    @Test
    public void test0334() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0334");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0335() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0335");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0336() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0336");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0337() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0337");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0338() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0338");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0339() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0339");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0340() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0340");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0341() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0341");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0342() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0342");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0343() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0343");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0344() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0344");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0345() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0345");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 8.167835760036914E54d + "'", double2 == 8.167835760036914E54d);
    }

    @Test
    public void test0346() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0346");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0347() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0347");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0348() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0348");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0349() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0349");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0350() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0350");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0351() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0351");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0352() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0352");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0353() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0353");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0354() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0354");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test0355() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0355");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0356() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0356");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0357() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0357");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0358() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0358");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0359() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0359");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0360() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0360");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0361() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0361");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0362() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0362");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1484630505472704E60d + "'", double2 == 1.1484630505472704E60d);
    }

    @Test
    public void test0363() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0363");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0364() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0364");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0365() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0365");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0366() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0366");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0367() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0367");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0368() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0368");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0369() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0369");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0370() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0370");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5714460626335824E49d + "'", double2 == 2.5714460626335824E49d);
    }

    @Test
    public void test0371() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0371");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0372() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0372");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0373() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0373");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0374() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0374");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0375() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0375");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0376() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0376");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0377() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0377");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0378() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0378");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0379() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0379");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0380() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0380");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.210245939718362E192d + "'", double2 == 5.210245939718362E192d);
    }

    @Test
    public void test0381() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0381");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0382() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0382");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0383() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0383");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0384() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0384");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0385() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0385");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.8335072785889182E166d + "'", double2 == 2.8335072785889182E166d);
    }

    @Test
    public void test0386() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0386");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0387() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0387");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0388() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0388");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0389() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0389");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0390() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0390");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0391() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0391");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0392() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0392");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0393() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0393");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0394() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0394");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0395() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0395");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0396() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0396");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0397() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0397");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0398() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0398");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0399() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0399");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0400() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0400");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0401() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0401");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0402() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0402");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0403() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0403");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0404() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0404");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0405() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0405");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0406() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0406");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0407() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0407");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0408() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0408");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0409() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0409");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0410() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0410");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0411() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0411");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test0412() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0412");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0413() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0413");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0414() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0414");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0415() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0415");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0416() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0416");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0417() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0417");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0418() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0418");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0419() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0419");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0420() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0420");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0421() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0421");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0422() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0422");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0423() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0423");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0424() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0424");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0425() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0425");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0426() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0426");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0427() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0427");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0428() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0428");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0429() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0429");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 8.167835760036914E54d + "'", double2 == 8.167835760036914E54d);
    }

    @Test
    public void test0430() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0430");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0431() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0431");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0432() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0432");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0433() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0433");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0434() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0434");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0435() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0435");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0436() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0436");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0437() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0437");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0438() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0438");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0439() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0439");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0440() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0440");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0441() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0441");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0442() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0442");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.0517771166437575E103d + "'", double2 == 2.0517771166437575E103d);
    }

    @Test
    public void test0443() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0443");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0444() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0444");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0445() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0445");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0446() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0446");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0447() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0447");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0448() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0448");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0449() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0449");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0450() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0450");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0451() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0451");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0452() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0452");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0453() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0453");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0454() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0454");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0455() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0455");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test0456() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0456");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0457() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0457");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0458() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0458");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0459() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0459");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0460() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0460");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0461() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0461");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0462() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0462");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0463() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0463");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0464() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0464");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0465() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0465");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0466() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0466");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0467() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0467");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0468() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0468");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0469() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0469");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0470() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0470");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0471() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0471");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0472() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0472");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0473() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0473");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0474() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0474");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0475() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0475");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0476() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0476");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0477() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0477");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test0478() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0478");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0479() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0479");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0480() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0480");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0481() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0481");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0482() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0482");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0483() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0483");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0484() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0484");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test0485() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0485");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0486() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0486");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0487() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0487");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.9567633533440073E80d + "'", double2 == 1.9567633533440073E80d);
    }

    @Test
    public void test0488() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0488");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test0489() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0489");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0490() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0490");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0491() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0491");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0492() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0492");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0493() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0493");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0494() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0494");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0495() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0495");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0496() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0496");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0497() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0497");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0498() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0498");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0499() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0499");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0500() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0500");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0501() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0501");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0502() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0502");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0503() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0503");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0504() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0504");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0505() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0505");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0506() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0506");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0507() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0507");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0508() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0508");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0509() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0509");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0510() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0510");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0511() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0511");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0512() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0512");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0513() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0513");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0514() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0514");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0515() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0515");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0516() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0516");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1025074993541484E54d + "'", double2 == 1.1025074993541484E54d);
    }

    @Test
    public void test0517() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0517");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0518() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0518");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0519() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0519");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0520() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0520");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0521() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0521");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0522() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0522");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0523() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0523");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0524() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0524");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0525() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0525");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0526() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0526");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0527() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0527");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0528() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0528");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0529() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0529");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.989595361011175E145d + "'", double2 == 9.989595361011175E145d);
    }

    @Test
    public void test0530() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0530");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0531() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0531");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0532() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0532");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0533() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0533");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7890485652059027E52d + "'", double2 == 4.7890485652059027E52d);
    }

    @Test
    public void test0534() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0534");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0535() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0535");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0536() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0536");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0537() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0537");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0538() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0538");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0539() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0539");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0540() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0540");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0541() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0541");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0542() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0542");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0543() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0543");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0544() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0544");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0545() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0545");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0546() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0546");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0547() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0547");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0548() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0548");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0549() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0549");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test0550() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0550");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0551() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0551");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0552() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0552");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0553() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0553");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0554() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0554");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0555() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0555");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0556() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0556");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0557() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0557");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0558() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0558");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0559() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0559");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0560() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0560");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test0561() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0561");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0562() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0562");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0563() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0563");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0564() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0564");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0565() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0565");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0566() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0566");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0567() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0567");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0568() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0568");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0569() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0569");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0570() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0570");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0571() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0571");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0572() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0572");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0573() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0573");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0574() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0574");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0575() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0575");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0576() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0576");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0577() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0577");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0578() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0578");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0579() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0579");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0580() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0580");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0581() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0581");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0582() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0582");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0583() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0583");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0584() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0584");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0585() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0585");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0586() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0586");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0587() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0587");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0588() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0588");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0589() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0589");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0590() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0590");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0591() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0591");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0592() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0592");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0593() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0593");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0594() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0594");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0595() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0595");
        double double2 = org.example.maths.PowerUsingRecursion.power(0.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0596() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0596");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.4435841430422168E69d + "'", double2 == 3.4435841430422168E69d);
    }

    @Test
    public void test0597() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0597");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0598() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0598");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.0517771166437575E103d + "'", double2 == 2.0517771166437575E103d);
    }

    @Test
    public void test0599() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0599");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0600() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0600");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0601() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0601");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0602() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0602");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0603() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0603");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0604() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0604");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0605() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0605");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0606() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0606");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0607() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0607");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0608() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0608");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0609() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0609");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0610() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0610");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0611() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0611");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0612() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0612");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0613() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0613");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0614() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0614");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0615() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0615");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0616() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0616");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0617() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0617");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0618() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0618");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0619() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0619");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0620() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0620");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0621() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0621");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0622() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0622");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0623() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0623");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0624() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0624");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0625() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0625");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0626() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0626");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0627() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0627");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0628() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0628");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0629() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0629");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0630() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0630");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0631() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0631");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0632() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0632");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0633() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0633");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0634() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0634");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.951141847926958E149d + "'", double2 == 5.951141847926958E149d);
    }

    @Test
    public void test0635() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0635");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0636() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0636");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0637() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0637");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0638() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0638");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0639() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0639");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0640() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0640");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0641() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0641");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0642() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0642");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0643() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0643");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0644() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0644");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0645() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0645");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0646() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0646");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0647() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0647");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0648() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0648");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0649() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0649");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0650() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0650");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0651() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0651");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0652() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0652");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0653() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0653");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0654() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0654");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0655() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0655");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0656() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0656");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0657() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0657");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0658() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0658");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0659() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0659");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test0660() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0660");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0661() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0661");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0662() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0662");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0663() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0663");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.9567633533440073E80d + "'", double2 == 1.9567633533440073E80d);
    }

    @Test
    public void test0664() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0664");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0665() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0665");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0666() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0666");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0667() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0667");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0668() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0668");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0669() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0669");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0670() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0670");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0671() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0671");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0672() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0672");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7890485652059027E52d + "'", double2 == 4.7890485652059027E52d);
    }

    @Test
    public void test0673() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0673");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0674() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0674");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0675() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0675");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0676() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0676");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0677() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0677");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0678() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0678");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0679() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0679");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0680() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0680");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0681() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0681");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7890485652059027E52d + "'", double2 == 4.7890485652059027E52d);
    }

    @Test
    public void test0682() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0682");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0683() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0683");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0684() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0684");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0685() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0685");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0686() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0686");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0687() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0687");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0688() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0688");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0689() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0689");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0690() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0690");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0691() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0691");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1025074993541484E54d + "'", double2 == 1.1025074993541484E54d);
    }

    @Test
    public void test0692() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0692");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0693() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0693");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0694() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0694");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0695() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0695");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0696() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0696");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0697() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0697");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test0698() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0698");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0699() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0699");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0700() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0700");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0701() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0701");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0702() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0702");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0703() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0703");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0704() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0704");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0705() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0705");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.210245939718362E192d + "'", double2 == 5.210245939718362E192d);
    }

    @Test
    public void test0706() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0706");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0707() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0707");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0708() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0708");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0709() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0709");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0710() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0710");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0711() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0711");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.951141847926958E149d + "'", double2 == 5.951141847926958E149d);
    }

    @Test
    public void test0712() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0712");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0713() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0713");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0714() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0714");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0715() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0715");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0716() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0716");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0717() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0717");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0718() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0718");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0719() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0719");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0720() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0720");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test0721() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0721");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0722() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0722");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0723() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0723");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0724() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0724");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0725() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0725");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0726() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0726");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test0727() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0727");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0728() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0728");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0729() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0729");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0730() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0730");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0731() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0731");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0732() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0732");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0733() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0733");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.7067655527413213E89d + "'", double2 == 1.7067655527413213E89d);
    }

    @Test
    public void test0734() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0734");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0735() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0735");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0736() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0736");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test0737() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0737");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0738() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0738");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0739() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0739");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0740() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0740");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0741() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0741");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.989595361011175E145d + "'", double2 == 9.989595361011175E145d);
    }

    @Test
    public void test0742() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0742");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0743() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0743");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0744() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0744");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0745() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0745");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0746() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0746");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0747() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0747");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0748() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0748");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0749() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0749");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0750() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0750");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0751() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0751");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0752() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0752");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0753() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0753");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0754() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0754");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0755() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0755");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0756() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0756");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0757() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0757");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0758() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0758");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.7067655527413213E89d + "'", double2 == 1.7067655527413213E89d);
    }

    @Test
    public void test0759() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0759");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0760() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0760");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0761() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0761");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0762() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0762");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0763() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0763");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0764() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0764");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0765() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0765");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0766() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0766");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test0767() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0767");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0768() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0768");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0769() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0769");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0770() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0770");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0771() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0771");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0772() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0772");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0773() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0773");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0774() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0774");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0775() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0775");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0776() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0776");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0777() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0777");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0778() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0778");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0779() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0779");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0780() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0780");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0781() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0781");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0782() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0782");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0783() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0783");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0784() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0784");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0785() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0785");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0786() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0786");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0787() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0787");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0788() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0788");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5714460626335824E49d + "'", double2 == 2.5714460626335824E49d);
    }

    @Test
    public void test0789() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0789");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0790() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0790");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0791() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0791");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0792() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0792");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0793() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0793");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0794() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0794");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0795() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0795");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0796() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0796");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0797() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0797");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0798() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0798");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0799() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0799");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0800() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0800");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0801() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0801");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0802() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0802");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0803() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0803");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0804() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0804");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0805() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0805");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0806() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0806");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0807() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0807");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0808() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0808");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0809() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0809");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0810() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0810");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test0811() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0811");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.989595361011175E145d + "'", double2 == 9.989595361011175E145d);
    }

    @Test
    public void test0812() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0812");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0813() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0813");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5714460626335824E49d + "'", double2 == 2.5714460626335824E49d);
    }

    @Test
    public void test0814() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0814");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0815() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0815");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.4615016373309029E48d + "'", double2 == 1.4615016373309029E48d);
    }

    @Test
    public void test0816() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0816");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0817() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0817");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0818() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0818");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0819() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0819");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.7067655527413213E89d + "'", double2 == 1.7067655527413213E89d);
    }

    @Test
    public void test0820() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0820");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0821() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0821");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0822() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0822");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0823() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0823");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0824() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0824");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test0825() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0825");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0826() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0826");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test0827() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0827");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0828() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0828");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0829() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0829");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0830() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0830");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0831() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0831");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0832() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0832");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0833() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0833");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0834() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0834");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0835() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0835");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0836() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0836");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0837() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0837");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0838() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0838");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E100d + "'", double2 == 1.0E100d);
    }

    @Test
    public void test0839() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0839");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0840() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0840");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test0841() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0841");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0842() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0842");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.8335072785889182E166d + "'", double2 == 2.8335072785889182E166d);
    }

    @Test
    public void test0843() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0843");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0844() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0844");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0845() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0845");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0846() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0846");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0847() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0847");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0848() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0848");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test0849() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0849");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0850() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0850");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0851() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0851");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0852() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0852");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0853() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0853");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 97.0d + "'", double2 == 97.0d);
    }

    @Test
    public void test0854() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0854");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0855() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0855");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0856() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0856");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0857() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0857");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test0858() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0858");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0859() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0859");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0860() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0860");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0861() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0861");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0862() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0862");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0863() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0863");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0864() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0864");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0865() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0865");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0866() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0866");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0867() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0867");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0868() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0868");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0869() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0869");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0870() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0870");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0871() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0871");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0872() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0872");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0873() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0873");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0874() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0874");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0875() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0875");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0876() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0876");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0877() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0877");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0878() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0878");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0879() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0879");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0880() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0880");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0881() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0881");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test0882() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0882");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1025074993541484E54d + "'", double2 == 1.1025074993541484E54d);
    }

    @Test
    public void test0883() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0883");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0884() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0884");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0885() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0885");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0886() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0886");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1L, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0887() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0887");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0888() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0888");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test0889() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0889");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0890() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0890");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.951141847926958E149d + "'", double2 == 5.951141847926958E149d);
    }

    @Test
    public void test0891() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0891");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0892() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0892");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0893() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0893");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0894() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0894");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0895() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0895");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0896() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0896");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0897() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0897");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0898() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0898");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.951141847926958E149d + "'", double2 == 5.951141847926958E149d);
    }

    @Test
    public void test0899() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0899");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.8335072785889182E166d + "'", double2 == 2.8335072785889182E166d);
    }

    @Test
    public void test0900() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0900");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0901() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0901");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0902() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0902");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0903() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0903");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0904() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0904");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0905() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0905");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.4615016373309029E48d + "'", double2 == 1.4615016373309029E48d);
    }

    @Test
    public void test0906() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0906");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0907() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0907");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0908() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0908");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0909() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0909");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0910() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0910");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5714460626335824E49d + "'", double2 == 2.5714460626335824E49d);
    }

    @Test
    public void test0911() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0911");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.8335072785889182E166d + "'", double2 == 2.8335072785889182E166d);
    }

    @Test
    public void test0912() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0912");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0913() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0913");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1.0f, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0914() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0914");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0915() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0915");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0916() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0916");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0917() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0917");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0918() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0918");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0919() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0919");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0920() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0920");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.4435841430422168E69d + "'", double2 == 3.4435841430422168E69d);
    }

    @Test
    public void test0921() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0921");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0922() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0922");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0923() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0923");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0924() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0924");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0925() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0925");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0926() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0926");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0927() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0927");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0928() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0928");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0929() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0929");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test0930() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0930");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0931() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0931");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0932() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0932");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test0933() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0933");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0934() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0934");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0935() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0935");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0936() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0936");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0937() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0937");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0938() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0938");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0939() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0939");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test0940() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0940");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0.0f, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0941() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0941");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test0942() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0942");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0943() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0943");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.8526734277970591E78d + "'", double2 == 1.8526734277970591E78d);
    }

    @Test
    public void test0944() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0944");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 8.167835760036914E54d + "'", double2 == 8.167835760036914E54d);
    }

    @Test
    public void test0945() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0945");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0946() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0946");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0947() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0947");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 1, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0948() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0948");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0949() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0949");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0950() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0950");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0951() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0951");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0952() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0952");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1025074993541484E54d + "'", double2 == 1.1025074993541484E54d);
    }

    @Test
    public void test0953() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0953");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E97d + "'", double2 == 1.0000000000000006E97d);
    }

    @Test
    public void test0954() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0954");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0955() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0955");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0956() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0956");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0957() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0957");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 0, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test0958() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0958");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0959() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0959");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0960() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0960");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test0961() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0961");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0962() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0962");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0963() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0963");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0964() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0964");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.8526734277970591E78d + "'", double2 == 1.8526734277970591E78d);
    }

    @Test
    public void test0965() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0965");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0966() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0966");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test0967() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0967");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0968() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0968");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0969() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0969");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.773075507922571E63d + "'", double2 == 3.773075507922571E63d);
    }

    @Test
    public void test0970() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0970");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0971() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0971");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0972() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0972");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0973() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0973");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test0974() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0974");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0975() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0975");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0976() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0976");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test0977() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0977");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test0978() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0978");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0979() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0979");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test0980() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0980");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test0981() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0981");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0982() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0982");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0983() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0983");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0984() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0984");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test0985() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0985");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0986() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0986");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0987() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0987");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.4615016373309029E48d + "'", double2 == 1.4615016373309029E48d);
    }

    @Test
    public void test0988() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0988");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0989() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0989");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0990() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0990");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test0991() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0991");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0992() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0992");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test0993() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0993");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test0994() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0994");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0995() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0995");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278307E171d + "'", double2 == 3.984137914278307E171d);
    }

    @Test
    public void test0996() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0996");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0997() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0997");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test0998() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0998");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test0999() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test0999");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E194d + "'", double2 == 1.0E194d);
    }

    @Test
    public void test1000() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1000");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test1001() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1001");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1002() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1002");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1003() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1003");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1004() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1004");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986834E154d + "'", double2 == 2.5515520672986834E154d);
    }

    @Test
    public void test1005() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1005");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test1006() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1006");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.4615016373309029E48d + "'", double2 == 1.4615016373309029E48d);
    }

    @Test
    public void test1007() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1007");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1008() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1008");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.210245939718362E192d + "'", double2 == 5.210245939718362E192d);
    }

    @Test
    public void test1009() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1009");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test1010() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1010");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1011() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1011");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test1012() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1012");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test1013() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1013");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test1014() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1014");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1015() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1015");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test1016() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1016");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1017() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1017");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1018() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1018");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1019() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1019");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test1020() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1020");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1021() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1021");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1022() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1022");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1023() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1023");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1024() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1024");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1025() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1025");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 32.0d + "'", double2 == 32.0d);
    }

    @Test
    public void test1026() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1026");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1027() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1027");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1028() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1028");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1029() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1029");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1030() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1030");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E100d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1031() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1031");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1032() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1032");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.210245939718362E192d + "'", double2 == 5.210245939718362E192d);
    }

    @Test
    public void test1033() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1033");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1034() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1034");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1035() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1035");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1036() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1036");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1484630505472704E60d + "'", double2 == 1.1484630505472704E60d);
    }

    @Test
    public void test1037() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1037");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1038() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1038");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1039() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1039");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test1040() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1040");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E52d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1041() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1041");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1042() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1042");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1043() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1043");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1044() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1044");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1045() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1045");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1046() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1046");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1047() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1047");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1048() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1048");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1049() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1049");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1050() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1050");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1051() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1051");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1052() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1052");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1053() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1053");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1054() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1054");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1055() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1055");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1056() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1056");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test1057() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1057");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test1058() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1058");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1484630505472704E60d + "'", double2 == 1.1484630505472704E60d);
    }

    @Test
    public void test1059() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1059");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.44555105949057024E17d + "'", double2 == 1.44555105949057024E17d);
    }

    @Test
    public void test1060() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1060");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1061() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1061");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1062() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1062");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1063() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1063");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1064() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1064");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1065() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1065");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1066() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1066");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1067() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1067");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1068() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1068");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1069() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1069");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test1070() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1070");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1071() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1071");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1072() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1072");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1073() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1073");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1074() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1074");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1075() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1075");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '4', (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.7067655527413213E89d + "'", double2 == 1.7067655527413213E89d);
    }

    @Test
    public void test1076() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1076");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.758547353515625E15d + "'", double2 == 2.758547353515625E15d);
    }

    @Test
    public void test1077() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1077");
        double double2 = org.example.maths.PowerUsingRecursion.power((-1.0d), (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1078() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1078");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.8526734277970591E78d + "'", double2 == 1.8526734277970591E78d);
    }

    @Test
    public void test1079() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1079");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1080() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1080");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1081() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1081");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1082() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1082");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1083() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1083");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test1084() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1084");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1085() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1085");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E35d + "'", double2 == 1.0E35d);
    }

    @Test
    public void test1086() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1086");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) ' ', 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test1087() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1087");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1088() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1088");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1089() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1089");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1090() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1090");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1091() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1091");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1025074993541484E54d + "'", double2 == 1.1025074993541484E54d);
    }

    @Test
    public void test1092() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1092");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1093() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1093");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1094() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1094");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1095() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1095");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.773075507922571E63d + "'", double2 == 3.773075507922571E63d);
    }

    @Test
    public void test1096() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1096");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1097() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1097");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) -1, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test1098() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1098");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test1099() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1099");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1100() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1100");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1101() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1101");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1102() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1102");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.7067655527413213E89d + "'", double2 == 1.7067655527413213E89d);
    }

    @Test
    public void test1103() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1103");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test1104() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1104");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1105() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1105");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1106() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1106");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1107() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1107");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1108() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1108");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1109() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1109");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1110() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1110");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1111() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1111");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1112() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1112");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1113() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1113");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1114() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1114");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1115() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1115");
        double double2 = org.example.maths.PowerUsingRecursion.power(8.167835760036914E54d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1116() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1116");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1117() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1117");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1118() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1118");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1119() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1119");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1025074993541484E54d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1120() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1120");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1121() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1121");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 10, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test1122() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1122");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1123() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1123");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1124() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1124");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.758547353515625E15d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test1125() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1125");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.9567633533440073E80d + "'", double2 == 1.9567633533440073E80d);
    }

    @Test
    public void test1126() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1126");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1127() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1127");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1128() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1128");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1129() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1129");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1130() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1130");
        double double2 = org.example.maths.PowerUsingRecursion.power(100.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1131() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1131");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1132() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1132");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1L), (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1133() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1133");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1134() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1134");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E35d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1135() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1135");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1136() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1136");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.8526734277970591E78d + "'", double2 == 1.8526734277970591E78d);
    }

    @Test
    public void test1137() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1137");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1138() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1138");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1139() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1139");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.4435841430422168E69d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1140() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1140");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E194d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1141() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1141");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1142() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1142");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 8.167835760036914E54d + "'", double2 == 8.167835760036914E54d);
    }

    @Test
    public void test1143() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1143");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000002E64d + "'", double2 == 1.0000000000000002E64d);
    }

    @Test
    public void test1144() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1144");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1145() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1145");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.773075507922571E63d + "'", double2 == 3.773075507922571E63d);
    }

    @Test
    public void test1146() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1146");
        double double2 = org.example.maths.PowerUsingRecursion.power(97.0d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test1147() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1147");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 1, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1148() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1148");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1149() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1149");
        double double2 = org.example.maths.PowerUsingRecursion.power(32.0d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.125899906842624E15d + "'", double2 == 1.125899906842624E15d);
    }

    @Test
    public void test1150() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1150");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1151() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1151");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1152() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1152");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1484630505472704E60d + "'", double2 == 1.1484630505472704E60d);
    }

    @Test
    public void test1153() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1153");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999999E31d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999999E31d + "'", double2 == 9.999999999999999E31d);
    }

    @Test
    public void test1154() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1154");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1155() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1155");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.5515520672986852E154d + "'", double2 == 2.5515520672986852E154d);
    }

    @Test
    public void test1156() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1156");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1157() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1157");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1158() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1158");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.773075507922571E63d + "'", double2 == 3.773075507922571E63d);
    }

    @Test
    public void test1159() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1159");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.8526734277970591E78d + "'", double2 == 1.8526734277970591E78d);
    }

    @Test
    public void test1160() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1160");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1161() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1161");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) '#', (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.9567633533440073E80d + "'", double2 == 1.9567633533440073E80d);
    }

    @Test
    public void test1162() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1162");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1163() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1163");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1164() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1164");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1165() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1165");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986834E154d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1166() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1166");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 52.0d + "'", double2 == 52.0d);
    }

    @Test
    public void test1167() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1167");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1168() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1168");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1.0f), (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1169() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1169");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1170() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1170");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1171() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1171");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000002E64d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1172() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1172");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1173() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1173");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1174() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1174");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 100, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 9.999999999999998E103d + "'", double2 == 9.999999999999998E103d);
    }

    @Test
    public void test1175() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1175");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test1176() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1176");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E70d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1177() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1177");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1178() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1178");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.125899906842624E15d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1179() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1179");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1180() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1180");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E10d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test1181() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1181");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 5.951141847926958E149d + "'", double2 == 5.951141847926958E149d);
    }

    @Test
    public void test1182() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1182");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5714460626335824E49d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1183() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1183");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E97d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1184() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1184");
        double double2 = org.example.maths.PowerUsingRecursion.power(52.0d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.984137914278306E171d + "'", double2 == 3.984137914278306E171d);
    }

    @Test
    public void test1185() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1185");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test1186() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1186");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 'a', (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.773075507922571E63d + "'", double2 == 3.773075507922571E63d);
    }

    @Test
    public void test1187() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1187");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1188() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1188");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1189() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1189");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1190() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1190");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.9567633533440073E80d + "'", double2 == 1.9567633533440073E80d);
    }

    @Test
    public void test1191() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1191");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.1484630505472704E60d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.1484630505472704E60d + "'", double2 == 1.1484630505472704E60d);
    }

    @Test
    public void test1192() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1192");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 10, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0000000000000006E100d + "'", double2 == 1.0000000000000006E100d);
    }

    @Test
    public void test1193() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1193");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1194() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1194");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1195() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1195");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (short) 100, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1196() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1196");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test1197() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1197");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1198() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1198");
        double double2 = org.example.maths.PowerUsingRecursion.power(7.374241268949283E19d, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 7.374241268949283E19d + "'", double2 == 7.374241268949283E19d);
    }

    @Test
    public void test1199() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1199");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test1200() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1200");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278306E171d, 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1201() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1201");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1202() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1202");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10.0f, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test1203() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1203");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1204() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1204");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (-1), (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + (-1.0d) + "'", double2 == (-1.0d));
    }

    @Test
    public void test1205() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1205");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7552507925405776E198d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 4.7552507925405776E198d + "'", double2 == 4.7552507925405776E198d);
    }

    @Test
    public void test1206() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1206");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test1207() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1207");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.44555105949057024E17d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1208() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1208");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.7067655527413213E89d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1209() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1209");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test1210() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1210");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.951141847926958E149d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1211() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1211");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test1212() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1212");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E200d + "'", double2 == 1.0E200d);
    }

    @Test
    public void test1213() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1213");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 100.0d + "'", double2 == 100.0d);
    }

    @Test
    public void test1214() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1214");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100L, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test1215() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1215");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0000000000000006E100d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1216() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1216");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.4615016373309029E48d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.4615016373309029E48d + "'", double2 == 1.4615016373309029E48d);
    }

    @Test
    public void test1217() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1217");
        double double2 = org.example.maths.PowerUsingRecursion.power(4.7890485652059027E52d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1218() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1218");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1219() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1219");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.984137914278307E171d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1220() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1220");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E52d + "'", double2 == 1.0E52d);
    }

    @Test
    public void test1221() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1221");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) -1, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1222() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1222");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0L, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1223() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1223");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (short) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1224() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1224");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 0, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1225() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1225");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1226() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1226");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100.0f, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E70d + "'", double2 == 1.0E70d);
    }

    @Test
    public void test1227() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1227");
        double double2 = org.example.maths.PowerUsingRecursion.power(Double.POSITIVE_INFINITY, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1228() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1228");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) (short) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1229() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1229");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.0517771166437575E103d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1230() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1230");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.8335072785889182E166d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 2.8335072785889182E166d + "'", double2 == 2.8335072785889182E166d);
    }

    @Test
    public void test1231() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1231");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 0, (int) (byte) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 0.0d + "'", double2 == 0.0d);
    }

    @Test
    public void test1232() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1232");
        double double2 = org.example.maths.PowerUsingRecursion.power(5.210245939718362E192d, (int) 'a');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1233() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1233");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.999999999999998E103d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1234() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1234");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.9567633533440073E80d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1235() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1235");
        double double2 = org.example.maths.PowerUsingRecursion.power(10.0d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 10.0d + "'", double2 == 10.0d);
    }

    @Test
    public void test1236() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1236");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 10L, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E10d + "'", double2 == 1.0E10d);
    }

    @Test
    public void test1237() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1237");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.8526734277970591E78d, 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1238() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1238");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.773075507922571E63d, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1239() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1239");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E20d, (int) (byte) 0);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1240() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1240");
        double double2 = org.example.maths.PowerUsingRecursion.power(35.0d, (int) (short) 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 35.0d + "'", double2 == 35.0d);
    }

    @Test
    public void test1241() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1241");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, 1);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 3.273390607896142E150d + "'", double2 == 3.273390607896142E150d);
    }

    @Test
    public void test1242() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1242");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) ' ');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1243() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1243");
        double double2 = org.example.maths.PowerUsingRecursion.power(9.989595361011175E145d, (int) '#');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1244() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1244");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) (byte) 1, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0d + "'", double2 == 1.0d);
    }

    @Test
    public void test1245() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1245");
        double double2 = org.example.maths.PowerUsingRecursion.power(2.5515520672986852E154d, (int) (short) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1246() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1246");
        double double2 = org.example.maths.PowerUsingRecursion.power(3.273390607896142E150d, (int) '4');
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1247() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1247");
        double double2 = org.example.maths.PowerUsingRecursion.power((double) 100, (int) (byte) 10);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + 1.0E20d + "'", double2 == 1.0E20d);
    }

    @Test
    public void test1248() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1248");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, (int) (byte) 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }

    @Test
    public void test1249() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PowerUsingRecursionRegressionTest0.test1249");
        double double2 = org.example.maths.PowerUsingRecursion.power(1.0E200d, 100);
        org.junit.Assert.assertTrue("'" + double2 + "' != '" + Double.POSITIVE_INFINITY + "'", double2 == Double.POSITIVE_INFINITY);
    }
}

